{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network Variant NoisyNet DQN implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement NoisyNet DQN variant of DQN. First part of the notebook is all about the vanilla DQN and how we train - a copy of `6_a_dqn_pytorch.ipynb`. The NoisyNet DQN variant is after these sections on vanilla DQN. \n",
    "\n",
    "\n",
    "### RECAP\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use $\\epsilon$-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update.\n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the $q(s,a)$ for all the actions in the state $s$. It is denoted as $ \\hat{q}(s_t, a_t; w_{t}) $, where $w_{t}$ is the weigths of the neural network that we learn as part of DQN learning.\n",
    "\n",
    "We use two networks, one target network with weight $w^-_t$ to get the max $q$-value of next state with best action denoted by $ \\max\\limits_a \\hat {q}(S_{t+1},a; w^{-}_{t}) $ and network with weights $w_t^-$ which we periodically updated from primary network $w_t$.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a;w^{-}_{t}) – \\hat{q}(S_t,A_t;w_t)] \\nabla_{w_t} \\hat{q}(S_t,A_t;w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values.\n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions `(current state, action, reward, next state)` in a buffer, where each sample is denoted as a tuple:\n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s'_{i}, done_{i})$$\n",
    "\n",
    "Subscript ($i$) denotes ith sample. We take $N$ samples from experience replay selecting randomly and update the weights. Subscript ($t$) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_{i},a';w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla_{w_t} \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Running in Colab/Kaggle\n",
    "\n",
    "If you are running this on Colab, please uncomment below cells and run this to install required dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment and execute this cell to install all the the dependencies if running in Google Colab\n",
    "\n",
    "# !apt-get update && apt-get install swig cmake ffmpeg freeglut3-dev xvfb\n",
    "# !pip install box2d-py\n",
    "# !pip install \"stable-baselines3[extra]>=2.1\"\n",
    "# !pip install \"huggingface_sb3>=3.0\"\n",
    "\n",
    "# !pip install git+https://github.com/DLR-RM/rl-baselines3-zoo@update/hf\n",
    "# !git clone https://github.com/DLR-RM/rl-baselines3-zoo\n",
    "# %cd rl-baselines3-zoo/\n",
    "# !pip install -r requirements.txt\n",
    "# %cd ..\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "from stable_baselines3.common.vec_env import VecVideoRecorder, DummyVecEnv\n",
    "from base64 import b64encode\n",
    "import time\n",
    "from tqdm import trange\n",
    "import glob\n",
    "from collections import namedtuple\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole. Readers can try to run this on many other environments like Lunar Lander and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name):\n",
    "    # increase time limit from 200/500 to 4000\n",
    "    env = gym.make(env_name, render_mode=\"rgb_array\", max_episode_steps=4000)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state shape:(4,)\n",
      "Number of Actions:2\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'CartPole-v1'\n",
    "seed=123\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset(seed=seed)\n",
    "plt.imshow(env.render())\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n\n",
    "print(f\"state shape:{state_shape}\\nNumber of Actions:{n_actions}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "\n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.network = nn.Sequential()\n",
    "        self.network.add_module('layer1', nn.Linear(state_dim, 256))\n",
    "        self.network.add_module('relu1', nn.ReLU())\n",
    "        self.network.add_module('layer2', nn.Linear(256, 256))\n",
    "        self.network.add_module('relu2', nn.ReLU())\n",
    "        self.network.add_module('layer3', nn.Linear(256, n_actions))\n",
    "        #\n",
    "        self.parameters = self.network.parameters\n",
    "\n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        qvalues = self.network(state_t)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and output is Qvals as numpy array\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)\n",
    "\n",
    "    def save(self, path):\n",
    "        print(\"path:\",path)\n",
    "        torch.save(self.network.state_dict(), f\"{path}.zip\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DQNAgent(\n",
       "  (network): Sequential(\n",
       "    (layer1): Linear(in_features=4, out_features=256, bias=True)\n",
       "    (relu1): ReLU()\n",
       "    (layer2): Linear(in_features=256, out_features=256, bias=True)\n",
       "    (relu2): ReLU()\n",
       "    (layer3): Linear(in_features=256, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s,_ = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, termiated, truncated,_ = env.step(action)\n",
    "            reward += r\n",
    "            if termiated:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon$-greedy) to sample from the environment and store the transitions `(s,a,r,s',done)` into a buffer. These samples are used multiple times in a learning making the process sample efficient.\n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to hold buffer\n",
    "        self.next_id = 0\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with DQN\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation:\n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}_{w_t}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_{w_t} L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a'} \\hat{q}(s'_i,a';w^-_t) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}_{w_t}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',a';w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network.\n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max\\limits_{a'} \\hat{q}(s'_i,a';w^-_t)$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$\n",
    "w_{t+1} \\leftarrow w_t - \\alpha . \\nabla_{w_t}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    predicted_qvalues = agent(states)\n",
    "\n",
    "    # compute q-values for all actions in next states\n",
    "    # use target network\n",
    "    predicted_next_qvalues = target_network(next_states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    predicted_qvalues_for_actions = predicted_qvalues[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    # compute Qmax(next_states, actions) using predicted next q-values\n",
    "    next_state_values,_ = torch.max(predicted_next_qvalues, dim=1)\n",
    "\n",
    "    # compute \"target q-values\"\n",
    "    target_qvalues_for_actions = rewards + gamma * next_state_values * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((predicted_qvalues_for_actions -\n",
    "                       target_qvalues_for_actions.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set up Environment and Policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#setup env and agent and target networks\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "state,_ = env.reset(seed=seed)\n",
    "\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train agent function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _  = env.reset(seed=seed)\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean return per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 30001/30001 [02:29<00:00, 200.41it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 305.23333333333335\n",
      "Well done\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n",
    "print('Well done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Record and Play a video of trained agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to record videos\n",
    "def record_video(env_id, video_folder, video_length, agent):\n",
    "\n",
    "    vec_env = DummyVecEnv([lambda: gym.make(env_id, render_mode=\"rgb_array\")])\n",
    "    # Record the video starting at the first step\n",
    "    vec_env = VecVideoRecorder(vec_env, video_folder,\n",
    "                           record_video_trigger=lambda x: x == 0, video_length=video_length,\n",
    "                           name_prefix=f\"{type(agent).__name__}-{env_id}\")\n",
    "\n",
    "    obs = vec_env.reset()\n",
    "    for _ in range(video_length + 1):\n",
    "        action = agent.get_action(obs).detach().cpu().numpy()\n",
    "        obs, _, _, _ = vec_env.step(action)\n",
    "    # video filename\n",
    "    file_path = \"./\"+video_folder+vec_env.video_recorder.path.split(\"/\")[-1]\n",
    "    # Save the video\n",
    "    vec_env.close()\n",
    "    return file_path\n",
    "\n",
    "def play_video(file_path):\n",
    "    mp4 = open(file_path, 'rb').read()\n",
    "    data_url = \"data:video/mp4;base64,\" + b64encode(mp4).decode()\n",
    "    return HTML(\"\"\"\n",
    "        <video width=400 controls>\n",
    "              <source src=\"%s\" type=\"video/mp4\">\n",
    "        </video>\n",
    "        \"\"\" % data_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/DQNAgent-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/DQNAgent-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_folder = \"logs/7_d/\"\n",
    "video_length = 500\n",
    "\n",
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NoisyNet-DQN\n",
    "\n",
    "The main idea is to replace ε-greedy policy used for exploration with a deterministic greedy policy. However, to explore random perturbations are added to linear layers as parameters which are learnt. The details are provided in the paper at https://arxiv.org/pdf/1706.10295.pdf\n",
    "\n",
    "The usual linear layers are affine transformations as given below\n",
    "\n",
    "$$ y = wx + b $$\n",
    "\n",
    "In Noisy Linear versions, we introduce random perturbations in the weights as given below:\n",
    "\n",
    "$$ y = (\\mu^w + \\sigma^w \\odot \\epsilon^w)x + (\\mu^b + \\sigma^b \\odot \\epsilon^b)  $$\n",
    "\n",
    "In above equation $\\mu^w$, $\\sigma^w$, $\\mu^b$, $\\sigma^b$ are the weights of the network that are learnt. $\\epsilon^w$ and $\\epsilon^b$ are random noises that introduce randomness leading to exploration.\n",
    "\n",
    "\n",
    "Code cells below show how this approach could be applied to any of the DQN variants. We create our own Noisy layer on the lines of Linear layer provided by torch. For this walk-through, we will use noisy version on DQN.  We also train using regular DQN approach. \n",
    "\n",
    "However, you could also try noisy version of DuelingDQN. Further, you could also try DDQN variant of learning as well. In other words, with what we have learnt so far, we could try following combinations:\n",
    "\n",
    "* DQN\n",
    "* DDQN (impacts how we learn)\n",
    "* Dueling DQN (impacts the architecture of training)\n",
    "* Dueling DDQN\n",
    "* replace $\\epsilon$-exploration with NoisyNet in any of the above approaches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Noisy Linear Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NoisyLinear(nn.Module):\n",
    "    def __init__(self, in_features, out_features, sigma_0 = 0.4):\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        self.in_features  = in_features\n",
    "        self.out_features = out_features\n",
    "        self.sigma_0= sigma_0\n",
    "        \n",
    "        self.mu_w = nn.Parameter(torch.FloatTensor(out_features, in_features))\n",
    "        self.sigma_w = nn.Parameter(torch.FloatTensor(out_features, in_features))\n",
    "        self.mu_b = nn.Parameter(torch.FloatTensor(out_features))\n",
    "        self.sigma_b = nn.Parameter(torch.FloatTensor(out_features))\n",
    "\n",
    "        self.register_buffer('epsilon_w', torch.FloatTensor(out_features, in_features))\n",
    "        self.register_buffer('epsilon_b', torch.FloatTensor(out_features))\n",
    "        \n",
    "        self.reset_noise()\n",
    "        self.reset_params()\n",
    "\n",
    "\n",
    "    def forward(self, x, training=False):\n",
    "        if training:\n",
    "            w = self.mu_w + self.sigma_w * self.epsilon_w\n",
    "            b = self.mu_b + self.sigma_b * self.epsilon_b\n",
    "        else:\n",
    "            w = self.mu_w\n",
    "            b = self.mu_b\n",
    "        return F.linear(x, w, b)        \n",
    "\n",
    "\n",
    "    def reset_params(self):\n",
    "        k = 1/self.in_features\n",
    "        k_sqrt = math.sqrt(k)\n",
    "        self.mu_w.data.uniform_(-k_sqrt, k_sqrt)\n",
    "        self.sigma_w.data.fill_(k_sqrt*self.sigma_0)\n",
    "        self.mu_b.data.uniform_(-k_sqrt, k_sqrt)\n",
    "        self.sigma_b.data.fill_(k_sqrt*self.sigma_0)\n",
    "\n",
    "    def reset_noise(self):\n",
    "        eps_in = self._noise(self.in_features)\n",
    "        eps_out = self._noise(self.out_features)\n",
    "        self.epsilon_w.copy_(eps_out.ger(eps_in)) \n",
    "        self.epsilon_b.copy_(self._noise(self.out_features))\n",
    "\n",
    "    def _noise(self, size):\n",
    "        x = torch.randn(size)\n",
    "        x = torch.sign(x)*torch.sqrt(torch.abs(x))\n",
    "        return x     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NoisyNet-DQN Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NoisyDQN(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions):\n",
    "        super(NoisyDQN, self).__init__()\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (input is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = NoisyLinear(state_dim, 64)\n",
    "        self.fc2 = NoisyLinear(64, 128)\n",
    "        self.fc3 = NoisyLinear(128, 32)\n",
    "        self.q = NoisyLinear(32, n_actions)\n",
    "\n",
    "        self.training=False\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the network to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t, training=self.training))\n",
    "        x = F.relu(self.fc2(x, training=self.training))\n",
    "        x = F.relu(self.fc3(x, training=self.training))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def get_action(self, states):\n",
    "        states = torch.tensor(np.array(states), device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions \n",
    "        \n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using greedy policy\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        return best_actions\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        self.fc1.reset_noise()\n",
    "        self.fc2.reset_noise()\n",
    "        self.fc3.reset_noise()\n",
    "        self.q.reset_noise()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup Training parameters and network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 5 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "# start_epsilon = 1\n",
    "# end_epsilon = 0.05\n",
    "# eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup some frequency for logging and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=45\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "env_name = 'CartPole-v1'\n",
    "env = make_env(env_name)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = NoisyDQN(state_dim, n_actions).to(device)\n",
    "target_network = NoisyDQN(state_dim, n_actions).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record_noisyNet(start_state, agent, env, exp_replay, n_steps=1, training=False):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    agent.training = training\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]\n",
    "        next_s, r, terminated, truncated, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        done = terminated or truncated\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s,_ = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "\n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Training Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent_noisy(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state, _ = env.reset(seed=seed)\n",
    "\n",
    "    # let us fill experience replay with some samples using full random policy    \n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    agent.training=True\n",
    "    for i in range(100):\n",
    "        agent.reset_noise()\n",
    "        play_and_record_noisyNet(state, agent, env, exp_replay, n_steps=10**2, training=True)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state, _ = env.reset(seed=seed)\n",
    "\n",
    "    #enable training flag\n",
    "    agent.training = True\n",
    "    target_network.training = True\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        with torch.no_grad():\n",
    "            _, state = play_and_record_noisyNet(state, agent, env, \n",
    "                                                exp_replay, \n",
    "                                                timesteps_per_epoch,\n",
    "                                                training=True)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        agent.reset_noise()\n",
    "        target_network.reset_noise()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            #disable training flag\n",
    "            agent.training = False\n",
    "            target_network.training = False\n",
    "\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(env_name), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i\" %\n",
    "                  (len(exp_replay)))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean return per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "            #enable training flag\n",
    "            agent.training = True\n",
    "            target_network.training = True\n",
    "\n",
    "    state, _ = env.reset(seed=seed)\n",
    "    #disable training flag\n",
    "    agent.training = False\n",
    "    target_network.training = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 50001/50001 [04:20<00:00, 191.62it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent_noisy(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score(Noisy DQN): 229\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(env_name),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score(Noisy DQN): {:.0f}'.format(final_score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving video to /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/NoisyDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "Moviepy - Building video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/NoisyDQN-CartPole-v1-step-0-to-step-500.mp4.\n",
      "Moviepy - Writing video /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/NoisyDQN-CartPole-v1-step-0-to-step-500.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                        \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /home/nsanghi/sandbox/apress/drl-2ed/chapter7/logs/7_d/NoisyDQN-CartPole-v1-step-0-to-step-500.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=400 controls>\n",
       "              <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video_file = record_video(env_name, video_folder, video_length, agent)\n",
    "\n",
    "play_video(video_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We also learnt a new way to explore i.e. to introduce some amount of randomness in the linear layer weights instead of using epsilon-greedy exploration. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
